package org.smartcomps.twister.util;
   
   import org.smartcomps.twister.engine.priv.core.definition.impl.PropertyImpl;
   
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
   
   import java.util.HashMap;
   import java.util.Date;
  import java.util.Collection;
  import java.util.ArrayList;
  import java.lang.reflect.Method;
  import java.lang.reflect.InvocationTargetException;
  
  /***
   * This class simply gives a random value to all properties of a JavaBean and
   * memorize it so that it can test, later on (after it has been persisted
   * and reloaded for exemple), that original values are still same.
   */
  public class BeanTester {
  
  	private static Log log = LogFactory.getLog(BeanTester.class);
  
  	public static final int STRING_LENGTH = 10;
  
  	private static final long FIFTY_YEARS_MS = 50*360*24*60*60*1000L;
  	private static final String SET_PREFIX = "set";
  	private static final String GET_PREFIX = "get";
  	private static final String IS_PREFIX = "is";
  
  	private HashMap beansValues = new HashMap();
  	private Collection ignoreList = null;
  
  	/***
  	 * Default constructor.
  	 */
  	public BeanTester() {
  		ignoreList = new ArrayList();
  	}
  
  	/***
  	 * Creates a BeanTester with a list of properties that will be ignored. The
  	 * BeanTester won't therefore try to assign those properties a value to test
  	 * it later on. The first letter of each property must be in high case.
  	 * @param ignoreList
  	 */
  	public BeanTester(String[] ignoreList) {
  		this.ignoreList = new ArrayList(ignoreList.length);
  		for (int m = 0; m < ignoreList.length; m++) {
  			String ignoreArg = ignoreList[m];
  			this.ignoreList.add(ignoreArg);
  		}
  	}
  
  	/***
  	 * Lets the BeanTester initialize all properties of a bean. It isolates all
  	 * properties of an object (basically from get and set methods following the
  	 * JavaBean specs and accepting simple types (String, Integer, Date, Long,
  	 * Boolean)) that aren't in the ignore list and sets them with a random value.
  	 * @param name all objects tested by the BeanTester must be named
  	 * @param bean object to test
  	 */
  	public void initializeProperties(String name, Object bean) {
  		Method[] beanMethods =  bean.getClass().getMethods();
  		for (int m = 0; m < beanMethods.length; m++) {
  			Method beanMethod = beanMethods[m];
  			String propName = isProperty(beanMethod);
  			if (propName != null && !ignoreList.contains(propName)) {
  				Object rndValue = generateRandomValue(beanMethod.getParameterTypes()[0]);
  				if (rndValue != null) {
  					boolean setted = false;
  					try {
  						beanMethod.invoke(bean, new Object[]{rndValue});
  						setted = true;
  					} catch (IllegalAccessException e) {
  						throw new RuntimeException("Could not invoke set" + propName + " with value " +
  								rndValue + " on object named " + name, e);
  					} catch (IllegalArgumentException e) {
  						throw new RuntimeException("Could not invoke set" + propName + " with value " +
  								rndValue + " on object named " + name, e);
  					} catch (InvocationTargetException e) {
  						log.warn("Could not invoke set" + propName + " with value " +
  								rndValue + " on object named " + name);
  					}
  					if (setted) {
  						log.info("Testing bean property " + propName + " for " + name);
  						beansValues.put(bean.getClass() + "(" + name + ")." + propName, rndValue);
  					}
  				}
  			}
  		}
  	}
  
  	/***
  	 * Tests the values of the properties that have been initialized
  	 * @param name must have the same value as for initialization
  	 * @param bean to test values
  	 * @return true if all properties have the same values in the provided bean
  	 */
 	public boolean testValues(String name, Object bean) {
 		boolean result = true;
 
 		Method[] beanMethods =  bean.getClass().getMethods();
 		for (int m = 0; m < beanMethods.length; m++) {
 			Method beanMethod = beanMethods[m];
 			String propName = isProperty(beanMethod);
 			if (propName != null && !ignoreList.contains(propName)) {
 				Object originalValue = beansValues.get(bean.getClass() + "(" + name + ")." + propName);
 				if (originalValue != null) {
 					Object currValue = null;
 					try {
                         Method getter = null;
                         try {
 						    getter = bean.getClass().getMethod(GET_PREFIX + propName, new Class[]{});
                         } catch (NoSuchMethodException e) {
                             getter = bean.getClass().getMethod(IS_PREFIX + propName, new Class[]{});
                         }
 						currValue = getter.invoke(bean, new Object[]{});
 					} catch (NoSuchMethodException e) {
 						throw new RuntimeException("Could not find get" + propName + " on object named " + name, e);
 					} catch (SecurityException e) {
 						throw new RuntimeException("Could not find get" + propName + " on object named " + name, e);
 					} catch (IllegalAccessException e) {
 						throw new RuntimeException("Could not invoke get" + propName + " on object named " + name, e);
 					} catch (InvocationTargetException e) {
 						throw new RuntimeException("Could not invoke get" + propName + " on object named " + name, e);
 					}
 
 					if (originalValue == null) {
 						if (currValue != null) {
 							result = false;
 							log.warn("Property " + propName + " changed, before " + originalValue +", now " + currValue);
 						}
 					} else  if (!originalValue.equals(currValue)) {
 						result = false;
 						log.warn("Property " + propName + " changed, before " + originalValue +", now " + currValue);
 					}
 				}
 			}
 		}
 
 		return result;
 	}
 
 	public static Object generateRandomValue(Class aClass) {
 		Object result = null;
 
 		double rand = Math.random();
 		if (aClass.equals(String.class)) {
 			result = "" + Math.round(rand * Math.pow(10, STRING_LENGTH));
 		} else if (aClass.equals(Integer.TYPE)) {
 			result = new Integer(new Long(Math.round(rand * Integer.MAX_VALUE)).intValue());
 		} else if (aClass.equals(Long.TYPE)) {
 			result = new Long(Math.round(rand * Integer.MAX_VALUE));
 		} else if (aClass.equals(Boolean.TYPE)) {
 			result = new Boolean(rand < 0.5);
 		} else if (aClass.equals(Date.class)) {
 			result = new Date(Math.round(rand * FIFTY_YEARS_MS));
 		}
 
 		return result;
 	}
 
 	private String isProperty(Method method) {
 
 		// Isolate a property from its set method
 		if (!method.getName().startsWith(SET_PREFIX)) {
 			return null;
 		}
 
 		// If setter has not exactly one parameter, it's not a right setter
 		if (method.getParameterTypes().length == 0 || method.getParameterTypes().length > 1) {
 			return null;
 		}
 
 		if (Collection.class.isAssignableFrom(method.getParameterTypes()[0])) {
 			return null;
 		}
 
 		// Must have a getter with same name
 		String propertyName = method.getName().substring(3);
 		Method correspondingGet = null;
 		Method[] methods = method.getDeclaringClass().getMethods();
 		for (int m = 0; m < methods.length; m++) {
 			Method anotherMethod = methods[m];
 			String anMethName = anotherMethod.getName();
 			if (anMethName.equals(GET_PREFIX + propertyName) || anMethName.equals(IS_PREFIX + propertyName)) {
 				if (anotherMethod.getParameterTypes().length == 0) {
 					correspondingGet = anotherMethod;
 				}
 			}
 		}
 		if (correspondingGet == null) return null;
 
 		// Getter must return something
 		if (correspondingGet.getReturnType() == null) return null;
 
 		// Getter must return same type has setter accepts
 		if (!correspondingGet.getReturnType().equals(method.getParameterTypes()[0])) {
 			return null;
 		}
 
 		return propertyName;
 	}
 
 //	public static void main(String[] args) {
 //		BeanTester tester = new BeanTester(new String[] {"Id"});
 //		PropertyImpl testBean = new PropertyImpl();
 //		testBean.setName("aName");
 //		testBean.setType("aType");
 //
 //		tester.initializeProperties("testBean", testBean);
 //		testBean.setId(new Long(12));
 //		testBean.setName("anotherName");
 //		System.out.println("Result : " + tester.testValues("testBean", testBean));
 //	}
 }